<html>
<head><meta charset="utf-8"><title>Never Rollup When Changing the `compiler`… compiler-team#407 · t-compiler/major changes · Zulip Chat Archive</title></head>
<h2>Stream: <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/index.html">t-compiler/major changes</a></h2>
<h3>Topic: <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html">Never Rollup When Changing the `compiler`… compiler-team#407</a></h3>

<hr>

<base href="https://rust-lang.zulipchat.com">

<head><link href="https://rust-lang.github.io/zulip_archive/style.css" rel="stylesheet"></head>

<a name="226406266"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226406266" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> triagebot <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226406266">(Feb 15 2021 at 16:40)</a>:</h4>
<p>A new proposal has been announced: <a href="https://github.com/rust-lang/compiler-team/issues/407">Never Rollup When Changing the <code>compiler</code> Directory #407</a>. It will be announced at the next meeting to try and draw attention to it, but usually MCPs are not discussed during triage meetings. If you think this would benefit from discussion amongst the team, consider proposing a design meeting.</p>



<a name="226406447"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226406447" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226406447">(Feb 15 2021 at 16:42)</a>:</h4>
<p>thought: this could also have a milder alternative: when people create a rollup (via <a href="https://bors.rust-lang.org/queue/rust">https://bors.rust-lang.org/queue/rust</a> I believe is the state of art today), make it obvious to people rolling up that they should prefer rolling up certain PRs but not others.</p>



<a name="226406468"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226406468" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226406468">(Feb 15 2021 at 16:42)</a>:</h4>
<p>and possibly warn that they are rolling up PRs that generally should go through queue normally.</p>



<a name="226406522"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226406522" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226406522">(Feb 15 2021 at 16:43)</a>:</h4>
<p>I believe we already have a <code>rollup=iffy</code>, so we could piggy-back on that.</p>



<a name="226410256"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226410256" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226410256">(Feb 15 2021 at 17:21)</a>:</h4>
<p>The problem is that even reviewers will mark the PRs as rollup=always</p>



<a name="226410317"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226410317" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226410317">(Feb 15 2021 at 17:22)</a>:</h4>
<p>I don't think the people rolling up are the ones who need to change, they don't have time to look at each PR individually</p>



<a name="226412493"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226412493" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226412493">(Feb 15 2021 at 17:41)</a>:</h4>
<p>yeah I meant to suggest that we'd apply <code>rollup=iffy</code> by default. Maybe even disallow <code>rollup=always</code> for changes touching <code>compiler/</code>. That would be less strict than forcing <code>rollup=never</code>.</p>



<a name="226412543"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226412543" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226412543">(Feb 15 2021 at 17:41)</a>:</h4>
<p>I don't know if the people doing rollups take the <code>iffy</code> flag into account when rolling up, but if they don't then I think the homu/bors interface could be adjusted to make it more apparent that these are iffy.</p>



<a name="226412619"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226412619" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> tm <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226412619">(Feb 15 2021 at 17:42)</a>:</h4>
<p>Do we know what impact this will have on time to land compiler related PR? Is the average daily number of successful bors runs &gt; average daily number of compiler related PRs that land currently?</p>



<a name="226412640"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226412640" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226412640">(Feb 15 2021 at 17:42)</a>:</h4>
<p>My primary concern is that we may get into a situation where we don't have any other choice but to rollup something, because the queue is full but everything that could be rolled up already was.</p>



<a name="226413127"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226413127" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226413127">(Feb 15 2021 at 17:47)</a>:</h4>
<p>I'm not familiar enough with the bors queue to say how frequently we run into an issue where we need to roll changes up to have any hope of getting the queue down. <code>rollup=iffy</code> is definitely another choice. It seems that many PRs are being labeled as "maybe", and still be rolled up despite (in my very humble opinion) they being very poor candidates for rollup.</p>



<a name="226413219"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226413219" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226413219">(Feb 15 2021 at 17:48)</a>:</h4>
<p>Encouraging those performing rollups to be cautious with certain PRs would be another positive change IMO</p>



<a name="226413953"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226413953" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226413953">(Feb 15 2021 at 17:54)</a>:</h4>
<p>Is <code>maybe</code> a separate rollup flag? I only know of <code>never</code>, <code>iffy</code>, default, <code>always</code> (in order from least rollable-up to the more rollable-up PRs)</p>



<a name="226414000"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226414000" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226414000">(Feb 15 2021 at 17:55)</a>:</h4>
<p>I think <code>maybe</code> might just be the default value?</p>



<a name="226414028"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226414028" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonas Schievink  [he/him] <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226414028">(Feb 15 2021 at 17:55)</a>:</h4>
<p>maybe is the default yeah</p>



<a name="226414846"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226414846" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226414846">(Feb 15 2021 at 18:03)</a>:</h4>
<p>Yes maybe is the default. I'd be curious to hear from those that do rollups on how they treat maybes - is there a general tendy to roll them up, do they check each one, etc.</p>



<a name="226414973"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226414973" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonas Schievink  [he/him] <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226414973">(Feb 15 2021 at 18:04)</a>:</h4>
<p>I tend to decide based on what code they touch</p>



<a name="226415049"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226415049" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jonas Schievink  [he/him] <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226415049">(Feb 15 2021 at 18:04)</a>:</h4>
<p>If they have a small diff, don't touch too many existing tests, and don't touch code that isn't tested during PR CI, I roll them up</p>



<a name="226415365"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226415365" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226415365">(Feb 15 2021 at 18:08)</a>:</h4>
<p>Yea it's tough. We've seen small refactorings (simply moving some code from one file to another) impact performance (usually do to inlining changes).</p>



<a name="226418142"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226418142" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226418142">(Feb 15 2021 at 18:42)</a>:</h4>
<p>I think my thoughts on this MCP are: by default, if <code>compiler</code> code is touched, then it should be <code>rollup=iffy</code>; other changes can stay <code>rollup=maybe</code> by default. But otherwise, the policy around manually changing from to <code>rollup=always</code> stays mostly the same: only in cases where it's obviously not going to affect perf, i.e. doc changes, variable renaming, typos, adding tests (and compiler-touching code can be a bit stricter here; small cleanups in library code might also be okay to be marked as <code>rollup=always</code>).</p>
<p>This way, the policy around <code>rollup=never</code> stays mostly the same: PRs that have a high likelihood of perf regressions, regressions, high impact, etc. This might be a good compromise between allowing small (3-5 PR) rollups when CI time is strained (where those might be a mix of <code>rollup=iffy</code> and <code>rollup=maybe</code>) (while also ensuring that PRs that really should <em>never</em> be rolled up aren't) and <em>generally</em> preferring compiler-touching code to not be rolled up.</p>



<a name="226421280"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226421280" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Eric Huss <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226421280">(Feb 15 2021 at 19:17)</a>:</h4>
<p>Just a little roughly scanned data: In the past 30 days there have been 171 merges (5.7/day). 31 of those were rollups, totaling 347 PRs (487 total PRs this past 30 days). Of the rollups, there were 157 total PRs that touched <code>/compiler/</code> (so roughly 5 compiler PRs per rollup).  </p>
<p>(This doesn't count beta or stable PRs.)</p>
<p>My instinct is that it will be difficult to reduce the number of compiler PRs in rollups. There's only going to be more PRs over time, and fewer merge slots per day.</p>



<a name="226490220"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226490220" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226490220">(Feb 16 2021 at 09:29)</a>:</h4>
<p>Thanks for the data. So ~45% of PRs involved in rollups touch the compiler folder. This certainly would decrease our ability to get through the bors queue. Perhaps we could first experiment with <code>rollup=iffy</code>as <span class="user-mention" data-user-id="123586">@nagisa</span> has suggested, but my worry would be that those doing rollups would learn to ignore the <code>iffy</code> labelling. </p>
<p>Perhaps we can come up with ways to more actively encouraging following the <a href="https://forge.rust-lang.org/release/rollups.html#selecting-pull-requests">guidelines</a> for which PRs to include in rollups. For instance, if a PR labeled as "maybe" or "iffy" contains more than n number of ".rs" files, we could require that the rollup paricipant actively opt into the "risky" rollup and we could specifically mention these PRs in the rollup PR.</p>



<a name="226492410"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226492410" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226492410">(Feb 16 2021 at 09:51)</a>:</h4>
<p>It's also interesting to note that I mostly see r+ rollup which defaults to <code>rollup=maybe</code> even for changes to documentation or other changes that are IMO very rollup friendly and should be marked <code>rollup=always</code>. Perhaps the entire rollup system is not being used as it was intended and needs some tweaking.</p>



<a name="226493568"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226493568" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226493568">(Feb 16 2021 at 10:01)</a>:</h4>
<p>My guess is that we can achieve almost anything with high precision by adjusting the interface people creating roll ups use. Right now it's checking a number of boxes and clicking a button. It is pretty easy to ignore the roll-up flag. If we grouped the prs by roll-up status in separate tables that would already make it way more what is safe to roll-up and what should be left alone. Grouping would also allow us to add some brief informational blurbs directly on the roll-up interface.</p>



<a name="226493746"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226493746" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226493746">(Feb 16 2021 at 10:03)</a>:</h4>
<p>Basically what I'm trying to say is we should put the responsibility on getting it right (more often) on the tooling not the people using it.</p>



<a name="226493899"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226493899" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226493899">(Feb 16 2021 at 10:04)</a>:</h4>
<p>(the other side of this equation is then automatically marking things as iffy ir never)</p>



<a name="226516699"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226516699" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226516699">(Feb 16 2021 at 14:09)</a>:</h4>
<p><span class="user-mention" data-user-id="224872">@rylev</span>  <code>r+ rollup</code> is the same as <code>rollup=always</code></p>



<a name="226516827"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226516827" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226516827">(Feb 16 2021 at 14:10)</a>:</h4>
<p><a href="https://forge.rust-lang.org/compiler/reviews.html?highlight=Rollup#rollups">https://forge.rust-lang.org/compiler/reviews.html?highlight=Rollup#rollups</a></p>



<a name="226516922"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226516922" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226516922">(Feb 16 2021 at 14:11)</a>:</h4>
<p>Ah the documentation is wrong in another part then:</p>
<blockquote>
<p>rollup=maybe: This is the default if you do not specify a rollup status.</p>
</blockquote>



<a name="226517043"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226517043" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226517043">(Feb 16 2021 at 14:12)</a>:</h4>
<p>I think it's just worded poorly and referring to <code>r+</code> without a rollup keyword</p>



<a name="226517149"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226517149" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226517149">(Feb 16 2021 at 14:13)</a>:</h4>
<p>Ok makes sense. We should clarify that.</p>



<a name="226517348"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226517348" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226517348">(Feb 16 2021 at 14:14)</a>:</h4>
<p>I'm not sure what good next steps are. I've seen PRs marked as <code>r+ rollup</code> that seem in direct contradiction to the guidelines for when to rollup. And it's clear that we're not doing a good job of rolling up because we almost <em>always</em> have at least one rollup regression in performance triage.</p>



<a name="226553219"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/226553219" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> scottmcm <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#226553219">(Feb 16 2021 at 18:16)</a>:</h4>
<p>Note that the prioritization of <code>rollup=never</code> meant that last time I tried <code>rollup=iffy</code> it meant that it took a really long time to get merged, since all the <code>never</code>s went first, and if it wasn't one of those, then the rollup got priority over it.</p>



<a name="227580571"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/227580571" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#227580571">(Feb 24 2021 at 10:55)</a>:</h4>
<p>I find myself a bit uncertain about how to use the rollup flags</p>



<a name="227580604"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/227580604" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#227580604">(Feb 24 2021 at 10:55)</a>:</h4>
<p>I feel like we could probably automate the default a lot better by looking at the size of the diff and/or changed files</p>



<a name="227580668"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/227580668" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#227580668">(Feb 24 2021 at 10:56)</a>:</h4>
<p>My hunch is that some simple heuristics would get us very far</p>



<a name="227589809"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/227589809" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#227589809">(Feb 24 2021 at 12:24)</a>:</h4>
<p>FYI: I'm going to revisit this to include suggestions based on the feedback so far.</p>



<a name="227778712"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/227778712" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#227778712">(Feb 25 2021 at 14:52)</a>:</h4>
<p>So to recap: we have a fundamental conflict of wanting to rollup as much as we can (to get through the queue faster) but to never rollup anything that breaks the build or hurts performance. I think an iterative approach to fixing rollups might be best. Some ideas:</p>
<ul>
<li>Logically assign "rollup=maybe" PRs 1 point, "rollup=iffy" PRs 2 points and "rollup=always" PRs zero points only allow 2 points total in each rollup and have bors clearly mark each PR that is not "rollup=always" as being "risky" in the rollup PR. This could allow easy rollup management by rerunning rollups without the risky PRs. </li>
<li>Default all PRs that are not explicitly marked with some rollup directive to "rollup=iffy" if they meet one of the following requirements:<ul>
<li>diffs larger than 10 lines in either compiler or bootstrap</li>
<li>diffs larger than 500 lines (no matter if they touch compiler or not)</li>
<li>We should add more over time</li>
</ul>
</li>
</ul>



<a name="227779136"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/227779136" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#227779136">(Feb 25 2021 at 14:54)</a>:</h4>
<blockquote>
<p>diffs larger than 10 lines in either compiler or bootstrap</p>
</blockquote>
<p>I don't think <em>any</em> heuristic for bootstrap can be accurate - half the time it's fixing typos, and the other half one-line changes have enormous impact: <a href="https://github.com/rust-lang/rust/pull/81214">https://github.com/rust-lang/rust/pull/81214</a></p>



<a name="227780200"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/227780200" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#227780200">(Feb 25 2021 at 15:01)</a>:</h4>
<p><span class="user-mention" data-user-id="232545">@Joshua Nelson</span> that's true though this is only for PRs where an explicit rollup status was not specified. In the case of only changing typos, the hope is that the reviewer explicitly marks it for rollup.</p>



<a name="227780255"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/227780255" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#227780255">(Feb 25 2021 at 15:01)</a>:</h4>
<p>sure, I guess I just don't think the heuristic will have any benefit over the reviewer's judgement</p>



<a name="227780357"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/227780357" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#227780357">(Feb 25 2021 at 15:02)</a>:</h4>
<p>usually when I leave out a status, it's because I mean <code>rollup=maybe</code></p>



<a name="227788166"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/227788166" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nagisa <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#227788166">(Feb 25 2021 at 15:48)</a>:</h4>
<p>In my experience performance changes in libstd are almost universally very small PRs.</p>



<a name="227904280"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/227904280" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#227904280">(Feb 26 2021 at 09:46)</a>:</h4>
<p>Ok so you're saying that you don't believe any heuristics will be able to better judge whether a PR should be <code>rollup=maybe</code> vs <code>rollup=iffy</code>?</p>



<a name="227904458"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/227904458" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#227904458">(Feb 26 2021 at 09:48)</a>:</h4>
<p>Having better metrics on this would help. We should be tracking how often rollups fail (either fail to build) or have performance regressions of some sort and ideally we could track it back to the PR that caused this and how that PR was labeled (rollup=always, rollup=maybe, etc.). It would be nice to know how often a PR labeled rollup=$label causes a failure.</p>



<a name="227936029"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/227936029" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#227936029">(Feb 26 2021 at 14:35)</a>:</h4>
<p><span class="user-mention silent" data-user-id="224872">rylev</span> <a href="#narrow/stream/233931-t-compiler.2Fmajor-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407/near/227904280">said</a>:</p>
<blockquote>
<p>Ok so you're saying that you don't believe any heuristics will be able to better judge whether a PR should be <code>rollup=maybe</code> vs <code>rollup=iffy</code>?</p>
</blockquote>
<p>specifically for <code>src/bootstrap</code>, yes</p>



<a name="228429683"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/228429683" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#228429683">(Mar 02 2021 at 15:34)</a>:</h4>
<p>When rollups fail because of a particular PR is the rollup status of that PR changed? Presumably if a PR causes a rollup build to fail, it should be labeled at least <code>rollup=iffy</code>, no?</p>



<a name="228430841"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/228430841" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#228430841">(Mar 02 2021 at 15:41)</a>:</h4>
<p>the problem is that we don't know that automatically, so it would need to be done manually. Right now, a comment is left on the PR and it is unassigned</p>



<a name="228430962"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/228430962" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#228430962">(Mar 02 2021 at 15:42)</a>:</h4>
<p>Anecdotally I would say that these PRs aren't more likely to fail future rollups, but... I guess I could measure that by looking at the history of some rollups</p>



<a name="228437350"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/228437350" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#228437350">(Mar 02 2021 at 16:17)</a>:</h4>
<p>I'd like to do an analysis of what rollupm status failed PRs received and how likely they are to fail future PRs.</p>



<a name="228572846"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/228572846" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#228572846">(Mar 03 2021 at 10:57)</a>:</h4>
<p>Some interesting patterns I've seen:</p>
<ul>
<li>Rollups that fail are retried with new PRs (instead of simply removing the failed PR and trying again). This sometimes leads to the new rollup failing due to the newly introduced PR. Shouldn't we simply remove the failed PR and try again? It seems that when doing so the rollup basically always succeeds.</li>
<li>I have noticed that anecdotally (this info is very hard to gather programmatically) that PRs that fail due tend to fail again (and then eventually succeed)</li>
</ul>



<a name="228573911"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/228573911" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#228573911">(Mar 03 2021 at 11:06)</a>:</h4>
<p>Some concrete suggestions:</p>
<ul>
<li>Close this MCP - this has turned into a general "improve rollups" discussion which is a larger discussion than the original MCP was meant for.</li>
<li>Add statistics gathering to bors:<ul>
<li>Give each rollup status a "risk" point value and start tracking how many points each rollup has </li>
</ul>
</li>
<li>Track the following questions:<ul>
<li>Are higher risk rollups more likely to fail?</li>
<li>What is a point value where the likelihood of failure reaches an acceptable level?</li>
</ul>
</li>
</ul>



<a name="228574010"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/228574010" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#228574010">(Mar 03 2021 at 11:07)</a>:</h4>
<p>We can take start here and then improve from there. In particular, I think it would be useful to better track that a PR has failed bors before. Those PRs should most likely be automatically labeled as at least rollup=iffy.</p>



<a name="228577887"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/233931-t-compiler/major%20changes/topic/Never%20Rollup%20When%20Changing%20the%20%60compiler%60%E2%80%A6%20compiler-team%23407/near/228577887" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> rylev <a href="https://rust-lang.github.io/zulip_archive/stream/233931-t-compiler/major-changes/topic/Never.20Rollup.20When.20Changing.20the.20.60compiler.60.E2.80.A6.20compiler-team.23407.html#228577887">(Mar 03 2021 at 11:45)</a>:</h4>
<p>(I've closed the MCP issue)</p>



<hr><p>Last updated: Aug 07 2021 at 22:04 UTC</p>
</html>